

<!DOCTYPE html>
<html lang="en">

<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Document</title>
    <style>
    /* base */
    html,
    body,
    .container {
      width: 100%;
      height: 100%;
    }

    a,
    a:link,
    a:visited {
      text-decoration: none;
      color: inherit;
    }

    ul {
      list-style: none;
    }

    *,
    ::before,
    ::after {
      box-sizing: border-box;
      margin: 0;
      padding: 0;
    }

    *:focus {
      outline: 0;
    }

    .container {
      display: flex;
      padding-top: 20px;
    }

    /* Nav */
    .container .doc-nav {
      position: fixed;
      height: 100%;
      margin: 0 30px 0 40px;
      width: 280px;
    }

    .doc-nav .nav-header {
      display: flex;
      align-items: center;
      box-sizing: border-box;
      background-color: rgb(240, 241, 242);
      height: 40px;
      padding: 16px;
      font-size: 18px;
      font-weight: 500;
      color: rgb(62, 64, 66);
      cursor: pointer;
    }

    .doc-nav .nav-content {
      height: calc(100% - 40px);
      overflow-y: auto;
      color: rgb(32, 34, 36);
    }

    .doc-nav .nav-content .nav-list,
    .doc-nav .nav-content .nav-sub-list {
      line-height: 1.5rem;
    }

    .doc-nav .nav-content .nav-label {
      display: inline-block;
      position: relative;
      padding: 2px 0 2px 20px;
      margin-bottom: 4px;
    }

    .doc-nav .nav-content .nav-sub-label {
      position: relative;
      padding: 2px 0 2px 40px;
      font-size: 14px;
    }

    .doc-nav .nav-content .nav-sub-label:hover {
      text-decoration: underline;
    }

    .doc-nav .nav-content .nav-list .nav-label.group::before {
      border-bottom: 0.25rem solid transparent;
      border-left: 0.25rem solid #6e7072;
      border-right: 0;
      border-top: 0.25rem solid transparent;
      content: '';
      display: block;
      height: 0;
      left: 0.5rem;
      position: absolute;
      top: 0.625rem;
      transition: transform 0.1s linear;
      width: 0;
    }

    .doc-nav .nav-content .nav-list .nav-label.group.active::before {
      transform: rotate(90deg);
    }

    /* doc content */
    .container .doc-content {
      position: fixed;
      height: 100%;
      width: calc(100% - 80px - 40px - 30px - 240px);
      right: 0%;
      overflow-y: auto;
    }

    .doc-title {
      border-bottom: 1px solid #dcdee0;
      font-size: 22px;
      margin: 8px 0 0;
      padding-bottom: 16px;
    }

    .doc-content h3 {
      font-size: 24px;
      font-weight: 600;
      margin: 24px 0;
    }

    .doc-content h4 {
      font-size: 22px;
      font-weight: 500;
      margin: 30px 0 8px;
    }

    .doc-content h4 span {
      color: #007d9c;
    }

    .doc-content .doc-declare {
      background-color: #fafafa;
      border-radius: 5px;
      border: 1px solid #ccc;
      font-size: 14px;
      overflow-x: auto;
      padding: 10px;
      tab-size: 4;
      line-height: 20px;
    }

    .doc-content .doc-comment {
      font-size: 16px;
      margin: 16px 0;
      line-height: 24px;
      word-break: break-word;
    }
  </style>

</head>
<body>
  <div class="container">
    <div class="doc-nav">
      <a href="#Documentation" class="nav-header">Documentation</a>
      <nav class="nav-content">
        <ul class="nav-list">
          <li>
            <a href="#includes" class="nav-label">Includes</a>
             
            <ul class="nav-sub-list">

              <li>
                <a href="#config.h" class="nav-sub-label">config.h</a>
              </li>
      

              <li>
                <a href="#MBEDTLS_CONFIG_FILE" class="nav-sub-label">MBEDTLS_CONFIG_FILE</a>
              </li>
      

              <li>
                <a href="#ecp.h" class="nav-sub-label">ecp.h</a>
              </li>
      
            </ul>
            
          </li>
          <li>
            <a href="#macros" class="nav-label">Macros</a>
             
            <ul class="nav-sub-list">

              <li>
                <a href="#MBEDTLS_ECDH_H" class="nav-sub-label">MBEDTLS_ECDH_H</a>
              </li>
      

              <li>
                <a href="#MBEDTLS_ECDH_LEGACY_CONTEXT" class="nav-sub-label">MBEDTLS_ECDH_LEGACY_CONTEXT</a>
              </li>
      
            </ul>
            
          </li>
          <li>
            <a href="#functions" class="nav-label">Functions</a>
             
            <ul class="nav-sub-list">

              <li>
                <a href="#mbedtls_ecdh_gen_public" class="nav-sub-label">mbedtls_ecdh_gen_public</a>
              </li>
      

              <li>
                <a href="#mbedtls_ecdh_compute_shared" class="nav-sub-label">mbedtls_ecdh_compute_shared</a>
              </li>
      

              <li>
                <a href="#mbedtls_ecdh_init" class="nav-sub-label">mbedtls_ecdh_init</a>
              </li>
      

              <li>
                <a href="#mbedtls_ecdh_setup" class="nav-sub-label">mbedtls_ecdh_setup</a>
              </li>
      

              <li>
                <a href="#mbedtls_ecdh_free" class="nav-sub-label">mbedtls_ecdh_free</a>
              </li>
      

              <li>
                <a href="#mbedtls_ecdh_make_params" class="nav-sub-label">mbedtls_ecdh_make_params</a>
              </li>
      

              <li>
                <a href="#mbedtls_ecdh_read_params" class="nav-sub-label">mbedtls_ecdh_read_params</a>
              </li>
      

              <li>
                <a href="#mbedtls_ecdh_get_params" class="nav-sub-label">mbedtls_ecdh_get_params</a>
              </li>
      

              <li>
                <a href="#mbedtls_ecdh_make_public" class="nav-sub-label">mbedtls_ecdh_make_public</a>
              </li>
      

              <li>
                <a href="#mbedtls_ecdh_read_public" class="nav-sub-label">mbedtls_ecdh_read_public</a>
              </li>
      

              <li>
                <a href="#mbedtls_ecdh_calc_secret" class="nav-sub-label">mbedtls_ecdh_calc_secret</a>
              </li>
      

              <li>
                <a href="#mbedtls_ecdh_enable_restart" class="nav-sub-label">mbedtls_ecdh_enable_restart</a>
              </li>
      
            </ul>
            
          </li>
          <li>
            <a href="#vars" class="nav-label">Vars</a>
            
            <ul class="nav-sub-list">
            
            </ul>
            
          </li>
          <li>
            <a href="#consts" class="nav-label">Consts</a>
            
            <ul class="nav-sub-list">
            
            </ul>
            
          </li>
          <li>
            <a href="#types" class="nav-label">Types</a>
            
            <ul class="nav-sub-list">
            
            </ul>
            
          </li>
          <li>
            <a href="#typedefs" class="nav-label">Typedefs</a>
             
            <ul class="nav-sub-list">

              <li>
                <a href="#mbedtls_ecdh_side;
" class="nav-sub-label">mbedtls_ecdh_side;
</a>
              </li>
      

              <li>
                <a href="#mbedtls_ecdh_variant;
" class="nav-sub-label">mbedtls_ecdh_variant;
</a>
              </li>
      

              <li>
                <a href="#mbedtls_ecdh_context_mbed;" class="nav-sub-label">mbedtls_ecdh_context_mbed;</a>
              </li>
      

              <li>
                <a href="#
mbedtls_ecdh_context;
" class="nav-sub-label">
mbedtls_ecdh_context;
</a>
              </li>
      
            </ul>
            
          </li>
        </ul>
      </nav>
    </div>
    <div class="doc-content">
      <h2 id="Documentation" class="doc-title">Documentation</h2>
      <h3 id="includes">Includes</h3>
      

      <h4 id="config.h"><span>config.h</span></h4>
      <pre class="doc-declare"><code>#include "config.h"
</code></pre>
      <pre class="doc-comment">#include "config.h"
</pre>

      <h4 id="MBEDTLS_CONFIG_FILE"><span>MBEDTLS_CONFIG_FILE</span></h4>
      <pre class="doc-declare"><code>#include MBEDTLS_CONFIG_FILE
</code></pre>
      <pre class="doc-comment">#include MBEDTLS_CONFIG_FILE
</pre>

      <h4 id="ecp.h"><span>ecp.h</span></h4>
      <pre class="doc-declare"><code>#include "ecp.h"
</code></pre>
      <pre class="doc-comment">#include "ecp.h"
</pre>
      <h3 id="macros">Macros</h3>
      

      <h4 id="MBEDTLS_ECDH_H">Marco <span>MBEDTLS_ECDH_H</span></h4>
      <pre class="doc-declare"><code>#define MBEDTLS_ECDH_H
</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="MBEDTLS_ECDH_LEGACY_CONTEXT">Marco <span>MBEDTLS_ECDH_LEGACY_CONTEXT</span></h4>
      <pre class="doc-declare"><code>#define MBEDTLS_ECDH_LEGACY_CONTEXT
</code></pre>
      <pre class="doc-comment">/*
 * Use a backward compatible ECDH context.
 *
 * This flag is always enabled for now and future versions might add a
 * configuration option that conditionally undefines this flag.
 * The configuration option in question may have a different name.
 *
 * Features undefining this flag, must have a warning in their description in
 * config.h stating that the feature breaks backward compatibility.
 */</pre>
      <h3 id="functions">Functions</h3>
      

      <h4 id="mbedtls_ecdh_gen_public">Func <span>mbedtls_ecdh_gen_public</span></h4>
      <pre class="doc-declare"><code>int mbedtls_ecdh_gen_public( mbedtls_ecp_group *grp, mbedtls_mpi *d, mbedtls_ecp_point *Q,
                    int (*f_rng)(void *, unsigned char *, size_t),
                    void *p_rng );</code></pre>
      <pre class="doc-comment">/**
 * \brief           This function generates an ECDH keypair on an elliptic
 *                  curve.
 *
 *                  This function performs the first of two core computations
 *                  implemented during the ECDH key exchange. The second core
 *                  computation is performed by mbedtls_ecdh_compute_shared().
 *
 * \see             ecp.h
 *
 * \param grp       The ECP group to use. This must be initialized and have
 *                  domain parameters loaded, for example through
 *                  mbedtls_ecp_load() or mbedtls_ecp_tls_read_group().
 * \param d         The destination MPI (private key).
 *                  This must be initialized.
 * \param Q         The destination point (public key).
 *                  This must be initialized.
 * \param f_rng     The RNG function to use. This must not be \c NULL.
 * \param p_rng     The RNG context to be passed to \p f_rng. This may be
 *                  \c NULL in case \p f_rng doesn't need a context argument.
 *
 * \return          \c 0 on success.
 * \return          Another \c MBEDTLS_ERR_ECP_XXX or
 *                  \c MBEDTLS_MPI_XXX error code on failure.
 */</pre>

      <h4 id="mbedtls_ecdh_compute_shared">Func <span>mbedtls_ecdh_compute_shared</span></h4>
      <pre class="doc-declare"><code>int mbedtls_ecdh_compute_shared( mbedtls_ecp_group *grp, mbedtls_mpi *z,
                        const mbedtls_ecp_point *Q, const mbedtls_mpi *d,
                        int (*f_rng)(void *, unsigned char *, size_t),
                        void *p_rng );</code></pre>
      <pre class="doc-comment">/**
 * \brief           This function computes the shared secret.
 *
 *                  This function performs the second of two core computations
 *                  implemented during the ECDH key exchange. The first core
 *                  computation is performed by mbedtls_ecdh_gen_public().
 *
 * \see             ecp.h
 *
 * \note            If \p f_rng is not NULL, it is used to implement
 *                  countermeasures against side-channel attacks.
 *                  For more information, see mbedtls_ecp_mul().
 *
 * \param grp       The ECP group to use. This must be initialized and have
 *                  domain parameters loaded, for example through
 *                  mbedtls_ecp_load() or mbedtls_ecp_tls_read_group().
 * \param z         The destination MPI (shared secret).
 *                  This must be initialized.
 * \param Q         The public key from another party.
 *                  This must be initialized.
 * \param d         Our secret exponent (private key).
 *                  This must be initialized.
 * \param f_rng     The RNG function. This may be \c NULL if randomization
 *                  of intermediate results during the ECP computations is
 *                  not needed (discouraged). See the documentation of
 *                  mbedtls_ecp_mul() for more.
 * \param p_rng     The RNG context to be passed to \p f_rng. This may be
 *                  \c NULL if \p f_rng is \c NULL or doesn't need a
 *                  context argument.
 *
 * \return          \c 0 on success.
 * \return          Another \c MBEDTLS_ERR_ECP_XXX or
 *                  \c MBEDTLS_MPI_XXX error code on failure.
 */</pre>

      <h4 id="mbedtls_ecdh_init">Func <span>mbedtls_ecdh_init</span></h4>
      <pre class="doc-declare"><code>void mbedtls_ecdh_init( mbedtls_ecdh_context *ctx );</code></pre>
      <pre class="doc-comment">/**
 * \brief           This function initializes an ECDH context.
 *
 * \param ctx       The ECDH context to initialize. This must not be \c NULL.
 */</pre>

      <h4 id="mbedtls_ecdh_setup">Func <span>mbedtls_ecdh_setup</span></h4>
      <pre class="doc-declare"><code>int mbedtls_ecdh_setup( mbedtls_ecdh_context *ctx,
                       mbedtls_ecp_group_id grp_id );</code></pre>
      <pre class="doc-comment">/**
 * \brief           This function sets up the ECDH context with the information
 *                  given.
 *
 *                  This function should be called after mbedtls_ecdh_init() but
 *                  before mbedtls_ecdh_make_params(). There is no need to call
 *                  this function before mbedtls_ecdh_read_params().
 *
 *                  This is the first function used by a TLS server for ECDHE
 *                  ciphersuites.
 *
 * \param ctx       The ECDH context to set up. This must be initialized.
 * \param grp_id    The group id of the group to set up the context for.
 *
 * \return          \c 0 on success.
 */</pre>

      <h4 id="mbedtls_ecdh_free">Func <span>mbedtls_ecdh_free</span></h4>
      <pre class="doc-declare"><code>void mbedtls_ecdh_free( mbedtls_ecdh_context *ctx );</code></pre>
      <pre class="doc-comment">/**
 * \brief           This function frees a context.
 *
 * \param ctx       The context to free. This may be \c NULL, in which
 *                  case this function does nothing. If it is not \c NULL,
 *                  it must point to an initialized ECDH context.
 */</pre>

      <h4 id="mbedtls_ecdh_make_params">Func <span>mbedtls_ecdh_make_params</span></h4>
      <pre class="doc-declare"><code>int mbedtls_ecdh_make_params( mbedtls_ecdh_context *ctx, size_t *olen,
                     unsigned char *buf, size_t blen,
                     int (*f_rng)(void *, unsigned char *, size_t),
                     void *p_rng );</code></pre>
      <pre class="doc-comment">/**
 * \brief           This function generates an EC key pair and exports its
 *                  in the format used in a TLS ServerKeyExchange handshake
 *                  message.
 *
 *                  This is the second function used by a TLS server for ECDHE
 *                  ciphersuites. (It is called after mbedtls_ecdh_setup().)
 *
 * \see             ecp.h
 *
 * \param ctx       The ECDH context to use. This must be initialized
 *                  and bound to a group, for example via mbedtls_ecdh_setup().
 * \param olen      The address at which to store the number of Bytes written.
 * \param buf       The destination buffer. This must be a writable buffer of
 *                  length \p blen Bytes.
 * \param blen      The length of the destination buffer \p buf in Bytes.
 * \param f_rng     The RNG function to use. This must not be \c NULL.
 * \param p_rng     The RNG context to be passed to \p f_rng. This may be
 *                  \c NULL in case \p f_rng doesn't need a context argument.
 *
 * \return          \c 0 on success.
 * \return          #MBEDTLS_ERR_ECP_IN_PROGRESS if maximum number of
 *                  operations was reached: see \c mbedtls_ecp_set_max_ops().
 * \return          Another \c MBEDTLS_ERR_ECP_XXX error code on failure.
 */</pre>

      <h4 id="mbedtls_ecdh_read_params">Func <span>mbedtls_ecdh_read_params</span></h4>
      <pre class="doc-declare"><code>int mbedtls_ecdh_read_params( mbedtls_ecdh_context *ctx,
                             const unsigned char **buf,
                             const unsigned char *end );</code></pre>
      <pre class="doc-comment">/**
 * \brief           This function parses the ECDHE parameters in a
 *                  TLS ServerKeyExchange handshake message.
 *
 * \note            In a TLS handshake, this is the how the client
 *                  sets up its ECDHE context from the server's public
 *                  ECDHE key material.
 *
 * \see             ecp.h
 *
 * \param ctx       The ECDHE context to use. This must be initialized.
 * \param buf       On input, \c *buf must be the start of the input buffer.
 *                  On output, \c *buf is updated to point to the end of the
 *                  data that has been read. On success, this is the first byte
 *                  past the end of the ServerKeyExchange parameters.
 *                  On error, this is the point at which an error has been
 *                  detected, which is usually not useful except to debug
 *                  failures.
 * \param end       The end of the input buffer.
 *
 * \return          \c 0 on success.
 * \return          An \c MBEDTLS_ERR_ECP_XXX error code on failure.
 *
 */</pre>

      <h4 id="mbedtls_ecdh_get_params">Func <span>mbedtls_ecdh_get_params</span></h4>
      <pre class="doc-declare"><code>int mbedtls_ecdh_get_params( mbedtls_ecdh_context *ctx,
                            const mbedtls_ecp_keypair *key,
                            mbedtls_ecdh_side side );</code></pre>
      <pre class="doc-comment">/**
 * \brief           This function sets up an ECDH context from an EC key.
 *
 *                  It is used by clients and servers in place of the
 *                  ServerKeyEchange for static ECDH, and imports ECDH
 *                  parameters from the EC key information of a certificate.
 *
 * \see             ecp.h
 *
 * \param ctx       The ECDH context to set up. This must be initialized.
 * \param key       The EC key to use. This must be initialized.
 * \param side      Defines the source of the key. Possible values are:
 *                  - #MBEDTLS_ECDH_OURS: The key is ours.
 *                  - #MBEDTLS_ECDH_THEIRS: The key is that of the peer.
 *
 * \return          \c 0 on success.
 * \return          Another \c MBEDTLS_ERR_ECP_XXX error code on failure.
 *
 */</pre>

      <h4 id="mbedtls_ecdh_make_public">Func <span>mbedtls_ecdh_make_public</span></h4>
      <pre class="doc-declare"><code>int mbedtls_ecdh_make_public( mbedtls_ecdh_context *ctx, size_t *olen,
                     unsigned char *buf, size_t blen,
                     int (*f_rng)(void *, unsigned char *, size_t),
                     void *p_rng );</code></pre>
      <pre class="doc-comment">/**
 * \brief           This function generates a public key and exports it
 *                  as a TLS ClientKeyExchange payload.
 *
 *                  This is the second function used by a TLS client for ECDH(E)
 *                  ciphersuites.
 *
 * \see             ecp.h
 *
 * \param ctx       The ECDH context to use. This must be initialized
 *                  and bound to a group, the latter usually by
 *                  mbedtls_ecdh_read_params().
 * \param olen      The address at which to store the number of Bytes written.
 *                  This must not be \c NULL.
 * \param buf       The destination buffer. This must be a writable buffer
 *                  of length \p blen Bytes.
 * \param blen      The size of the destination buffer \p buf in Bytes.
 * \param f_rng     The RNG function to use. This must not be \c NULL.
 * \param p_rng     The RNG context to be passed to \p f_rng. This may be
 *                  \c NULL in case \p f_rng doesn't need a context argument.
 *
 * \return          \c 0 on success.
 * \return          #MBEDTLS_ERR_ECP_IN_PROGRESS if maximum number of
 *                  operations was reached: see \c mbedtls_ecp_set_max_ops().
 * \return          Another \c MBEDTLS_ERR_ECP_XXX error code on failure.
 */</pre>

      <h4 id="mbedtls_ecdh_read_public">Func <span>mbedtls_ecdh_read_public</span></h4>
      <pre class="doc-declare"><code>int mbedtls_ecdh_read_public( mbedtls_ecdh_context *ctx,
                             const unsigned char *buf, size_t blen );</code></pre>
      <pre class="doc-comment">/**
 * \brief       This function parses and processes the ECDHE payload of a
 *              TLS ClientKeyExchange message.
 *
 *              This is the third function used by a TLS server for ECDH(E)
 *              ciphersuites. (It is called after mbedtls_ecdh_setup() and
 *              mbedtls_ecdh_make_params().)
 *
 * \see         ecp.h
 *
 * \param ctx   The ECDH context to use. This must be initialized
 *              and bound to a group, for example via mbedtls_ecdh_setup().
 * \param buf   The pointer to the ClientKeyExchange payload. This must
 *              be a readable buffer of length \p blen Bytes.
 * \param blen  The length of the input buffer \p buf in Bytes.
 *
 * \return      \c 0 on success.
 * \return      An \c MBEDTLS_ERR_ECP_XXX error code on failure.
 */</pre>

      <h4 id="mbedtls_ecdh_calc_secret">Func <span>mbedtls_ecdh_calc_secret</span></h4>
      <pre class="doc-declare"><code>int mbedtls_ecdh_calc_secret( mbedtls_ecdh_context *ctx, size_t *olen,
                     unsigned char *buf, size_t blen,
                     int (*f_rng)(void *, unsigned char *, size_t),
                     void *p_rng );</code></pre>
      <pre class="doc-comment">/**
 * \brief           This function derives and exports the shared secret.
 *
 *                  This is the last function used by both TLS client
 *                  and servers.
 *
 * \note            If \p f_rng is not NULL, it is used to implement
 *                  countermeasures against side-channel attacks.
 *                  For more information, see mbedtls_ecp_mul().
 *
 * \see             ecp.h

 * \param ctx       The ECDH context to use. This must be initialized
 *                  and have its own private key generated and the peer's
 *                  public key imported.
 * \param olen      The address at which to store the total number of
 *                  Bytes written on success. This must not be \c NULL.
 * \param buf       The buffer to write the generated shared key to. This
 *                  must be a writable buffer of size \p blen Bytes.
 * \param blen      The length of the destination buffer \p buf in Bytes.
 * \param f_rng     The RNG function, for blinding purposes. This may
 *                  b \c NULL if blinding isn't needed.
 * \param p_rng     The RNG context. This may be \c NULL if \p f_rng
 *                  doesn't need a context argument.
 *
 * \return          \c 0 on success.
 * \return          #MBEDTLS_ERR_ECP_IN_PROGRESS if maximum number of
 *                  operations was reached: see \c mbedtls_ecp_set_max_ops().
 * \return          Another \c MBEDTLS_ERR_ECP_XXX error code on failure.
 */</pre>

      <h4 id="mbedtls_ecdh_enable_restart">Func <span>mbedtls_ecdh_enable_restart</span></h4>
      <pre class="doc-declare"><code>void mbedtls_ecdh_enable_restart( mbedtls_ecdh_context *ctx );</code></pre>
      <pre class="doc-comment">/**
 * \brief           This function enables restartable EC computations for this
 *                  context.  (Default: disabled.)
 *
 * \see             \c mbedtls_ecp_set_max_ops()
 *
 * \note            It is not possible to safely disable restartable
 *                  computations once enabled, except by free-ing the context,
 *                  which cancels possible in-progress operations.
 *
 * \param ctx       The ECDH context to use. This must be initialized.
 */</pre>
      <h3 id="vars">Vars</h3>
      
      <h3 id="consts">Consts</h3>
      
      <h3 id="types">Types</h3>
      
      <h3 id="typedefs">Typedefs</h3>
      

      <h4 id="mbedtls_ecdh_side;
">Typedef <span>mbedtls_ecdh_side;
</span></h4>
      <pre class="doc-declare"><code>typedef enum
{
   MBEDTLS_ECDH_OURS,  /**< Our key. */
   MBEDTLS_ECDH_THEIRS, /**< The key of the peer. */
} mbedtls_ecdh_side;
</code></pre>
      <pre class="doc-comment">/**
 * Defines the source of the imported EC key.
 */</pre>

      <h4 id="mbedtls_ecdh_variant;
">Typedef <span>mbedtls_ecdh_variant;
</span></h4>
      <pre class="doc-declare"><code>typedef enum
{
   MBEDTLS_ECDH_VARIANT_NONE = 0,  /*!< Implementation not defined. */
   MBEDTLS_ECDH_VARIANT_MBEDTLS_2_0,/*!< The default Mbed TLS implementation */
} mbedtls_ecdh_variant;
</code></pre>
      <pre class="doc-comment">/**
 * Defines the ECDH implementation used.
 *
 * Later versions of the library may add new variants, therefore users should
 * not make any assumptions about them.
 */</pre>

      <h4 id="mbedtls_ecdh_context_mbed;">Typedef <span>mbedtls_ecdh_context_mbed;</span></h4>
      <pre class="doc-declare"><code>typedef struct mbedtls_ecdh_context_mbed
{
   mbedtls_ecp_group grp;  /*!< The elliptic curve used. */
   mbedtls_mpi d;          /*!< The private key. */
   mbedtls_ecp_point Q;    /*!< The public key. */
   mbedtls_ecp_point Qp;   /*!< The value of the public key of the peer. */
   mbedtls_mpi z;          /*!< The shared secret. */
#if defined(MBEDTLS_ECP_RESTARTABLE)
   mbedtls_ecp_restart_ctx rs; /*!< The restart context for EC computations. */
#endif
} mbedtls_ecdh_context_mbed;</code></pre>
      <pre class="doc-comment">/**
 * The context used by the default ECDH implementation.
 *
 * Later versions might change the structure of this context, therefore users
 * should not make any assumptions about the structure of
 * mbedtls_ecdh_context_mbed.
 */</pre>

      <h4 id="
mbedtls_ecdh_context;
">Typedef <span>
mbedtls_ecdh_context;
</span></h4>
      <pre class="doc-declare"><code>typedef struct mbedtls_ecdh_context
{
#if defined(MBEDTLS_ECDH_LEGACY_CONTEXT)
   mbedtls_ecp_group grp;  /*!< The elliptic curve used. */
   mbedtls_mpi d;          /*!< The private key. */
   mbedtls_ecp_point Q;    /*!< The public key. */
   mbedtls_ecp_point Qp;   /*!< The value of the public key of the peer. */
   mbedtls_mpi z;          /*!< The shared secret. */
   int point_format;       /*!< The format of point export in TLS messages. */
   mbedtls_ecp_point Vi;   /*!< The blinding value. */
   mbedtls_ecp_point Vf;   /*!< The unblinding value. */
   mbedtls_mpi _d;         /*!< The previous \p d. */
#if defined(MBEDTLS_ECP_RESTARTABLE)
   int restart_enabled;       /*!< The flag for restartable mode. */
   mbedtls_ecp_restart_ctx rs; /*!< The restart context for EC computations. */
#endif /* MBEDTLS_ECP_RESTARTABLE */
#else
   uint8_t point_format;      /*!< The format of point export in TLS messages
                                  as defined in RFC 4492. */
   mbedtls_ecp_group_id grp_id;/*!< The elliptic curve used. */
   mbedtls_ecdh_variant var;  /*!< The ECDH implementation/structure used. */
   union
   {
       mbedtls_ecdh_context_mbed  mbed_ecdh;
   } ctx;                                          /*!< Implementation-specific context. The
                                  context in use is specified by the \c var
                                  field. */
#if defined(MBEDTLS_ECP_RESTARTABLE)
   uint8_t restart_enabled;      /*!< The flag for restartable mode. Functions of
                                  an alternative implementation not supporting
                                  restartable mode must return
                                  MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED error
                                  if this flag is set. */
#endif /* MBEDTLS_ECP_RESTARTABLE */
#endif /* MBEDTLS_ECDH_LEGACY_CONTEXT */
}
mbedtls_ecdh_context;
</code></pre>
      <pre class="doc-comment">/**
 *
 * \warning         Performing multiple operations concurrently on the same
 *                  ECDSA context is not supported; objects of this type
 *                  should not be shared between multiple threads.
 * \brief           The ECDH context structure.
 */</pre>
    </div>
  </body>
</html>
            